
#include <cmath>
#include "IClassFloat.h"
#include "member_BClass.h"

using namespace BWE;

ClassFloat::ClassFloat() : BClass("float", true)
{

	insertMethod("float()", &ClassFloat::create);
	insertMethod("float(bool)", &ClassFloat::create_bool);
	insertMethod("float(char)", &ClassFloat::create_char);
	insertMethod("float(short)", &ClassFloat::create_short);
	insertMethod("float(int)", &ClassFloat::create_int);
	insertMethod("float(long)", &ClassFloat::create_long);
	insertMethod("float(real)", &ClassFloat::create_real);
	insertMethod("float(float)", &ClassFloat::create_float);
	insertMethod("float(double)", &ClassFloat::create_double);

	insertMethod("float =(bool)", &ClassFloat::assign_bool);
	insertMethod("float =(char)", &ClassFloat::assign_char);
	insertMethod("float =(short)", &ClassFloat::assign_short);
	insertMethod("float =(int)", &ClassFloat::assign_int);
	insertMethod("float =(long)", &ClassFloat::assign_long);
	insertMethod("float =(real)", &ClassFloat::assign_real);
	insertMethod("float =(float)", &ClassFloat::assign_float);
	insertMethod("float =(double)", &ClassFloat::assign_double);

	insertMethod("float +()", &ClassFloat::positive);
	insertMethod("float -()", &ClassFloat::negative);
	insertMethod("float ++()", &ClassFloat::plus_plus);
	insertMethod("float --()", &ClassFloat::minus_minus);

	insertMethod("float +(char)", &ClassFloat::plus_char);
	insertMethod("float +(short)", &ClassFloat::plus_short);
	insertMethod("float +(int)", &ClassFloat::plus_int);
	insertMethod("float +(long)", &ClassFloat::plus_long);
	insertMethod("float +(real)", &ClassFloat::plus_real);
	insertMethod("float +(float)", &ClassFloat::plus_float);
	insertMethod("double +(double)", &ClassFloat::plus_double);

	insertMethod("+=(char)", &ClassFloat::plus_assign_char);
	insertMethod("+=(short)", &ClassFloat::plus_assign_short);
	insertMethod("+=(int)", &ClassFloat::plus_assign_int);
	insertMethod("+=(long)", &ClassFloat::plus_assign_long);
	insertMethod("+=(real)", &ClassFloat::plus_assign_real);
	insertMethod("+=(float)", &ClassFloat::plus_assign_float);
	insertMethod("+=(double)", &ClassFloat::plus_assign_double);

	insertMethod("float -(char)", &ClassFloat::minus_char);
	insertMethod("float -(short)", &ClassFloat::minus_short);
	insertMethod("float -(int)", &ClassFloat::minus_int);
	insertMethod("float -(long)", &ClassFloat::minus_long);
	insertMethod("float -(real)", &ClassFloat::minus_real);
	insertMethod("float -(float)", &ClassFloat::minus_float);
	insertMethod("double -(double)", &ClassFloat::minus_double);

	insertMethod("-=(char)", &ClassFloat::minus_assign_char);
	insertMethod("-=(short)", &ClassFloat::minus_assign_short);
	insertMethod("-=(int)", &ClassFloat::minus_assign_int);
	insertMethod("-=(long)", &ClassFloat::minus_assign_long);
	insertMethod("-=(real)", &ClassFloat::minus_assign_real);
	insertMethod("-=(float)", &ClassFloat::minus_assign_float);
	insertMethod("-=(double)", &ClassFloat::minus_assign_double);

	insertMethod("float *(char)",		&ClassFloat::mult_char);
	insertMethod("float *(short)",		&ClassFloat::mult_short);
	insertMethod("float *(int)",		&ClassFloat::mult_int);
	insertMethod("float *(long)",		&ClassFloat::mult_long);
	insertMethod("float *(real)",		&ClassFloat::mult_real);
	insertMethod("float *(float)",		&ClassFloat::mult_float);
	insertMethod("double *(double)",	&ClassFloat::mult_double);

	insertMethod("*=(char)",	&ClassFloat::mult_assign_char);
	insertMethod("*=(short)",	&ClassFloat::mult_assign_short);
	insertMethod("*=(int)",		&ClassFloat::mult_assign_int);
	insertMethod("*=(long)",	&ClassFloat::mult_assign_long);
	insertMethod("*=(real)",	&ClassFloat::mult_assign_real);
	insertMethod("*=(float)",	&ClassFloat::mult_assign_float);
	insertMethod("*=(double)",	&ClassFloat::mult_assign_double);

	insertMethod("float /(char)",		&ClassFloat::div_char);
	insertMethod("float /(short)",		&ClassFloat::div_short);
	insertMethod("float /(int)",		&ClassFloat::div_int);
	insertMethod("float /(long)",		&ClassFloat::div_long);
	insertMethod("float /(real)",		&ClassFloat::div_real);
	insertMethod("float /(float)",		&ClassFloat::div_float);
	insertMethod("double /(double)",	&ClassFloat::div_double);

	insertMethod("/=(char)",	&ClassFloat::div_assign_char);
	insertMethod("/=(short)",	&ClassFloat::div_assign_short);
	insertMethod("/=(int)",		&ClassFloat::div_assign_int);
	insertMethod("/=(long)",	&ClassFloat::div_assign_long);
	insertMethod("/=(real)",	&ClassFloat::div_assign_real);
	insertMethod("/=(float)",	&ClassFloat::div_assign_float);
	insertMethod("/=(double)",	&ClassFloat::div_assign_double);

	insertMethod("float %(char)",		&ClassFloat::mod_char);
	insertMethod("float %(short)",		&ClassFloat::mod_short);
	insertMethod("float %(int)",		&ClassFloat::mod_int);
	insertMethod("float %(long)",		&ClassFloat::mod_long);
	insertMethod("float %(real)",		&ClassFloat::mod_real);
	insertMethod("float %(float)",		&ClassFloat::mod_float);
	insertMethod("double %(double)",	&ClassFloat::mod_double);

	insertMethod("%=(char)",	&ClassFloat::mod_assign_char);
	insertMethod("%=(short)",	&ClassFloat::mod_assign_short);
	insertMethod("%=(int)",		&ClassFloat::mod_assign_int);
	insertMethod("%=(long)",	&ClassFloat::mod_assign_long);
	insertMethod("%=(real)",	&ClassFloat::mod_assign_real);
	insertMethod("%=(float)",	&ClassFloat::mod_assign_float);
	insertMethod("%=(double)",	&ClassFloat::mod_assign_double);

	insertMethod("bool ==(char)", &ClassFloat::equal_char);
	insertMethod("bool ==(short)", &ClassFloat::equal_short);
	insertMethod("bool ==(int)", &ClassFloat::equal_int);
	insertMethod("bool ==(long)", &ClassFloat::equal_long);
	insertMethod("bool ==(real)", &ClassFloat::equal_real);
	insertMethod("bool ==(float)", &ClassFloat::equal_float);
	insertMethod("bool ==(double)", &ClassFloat::equal_double);

	insertMethod("bool !=(char)", &ClassFloat::unequal_char);
	insertMethod("bool !=(short)", &ClassFloat::unequal_short);
	insertMethod("bool !=(int)", &ClassFloat::unequal_int);
	insertMethod("bool !=(long)", &ClassFloat::unequal_long);
	insertMethod("bool !=(real)", &ClassFloat::unequal_real);
	insertMethod("bool !=(float)", &ClassFloat::unequal_float);
	insertMethod("bool !=(double)", &ClassFloat::unequal_double);

	insertMethod("bool >(char)", &ClassFloat::greater_char);
	insertMethod("bool >(short)", &ClassFloat::greater_short);
	insertMethod("bool >(int)", &ClassFloat::greater_int);
	insertMethod("bool >(long)", &ClassFloat::greater_long);
	insertMethod("bool >(real)", &ClassFloat::greater_real);
	insertMethod("bool >(float)", &ClassFloat::greater_float);
	insertMethod("bool >(double)", &ClassFloat::greater_double);

	insertMethod("bool <(char)", &ClassFloat::less_char);
	insertMethod("bool <(short)", &ClassFloat::less_short);
	insertMethod("bool <(int)", &ClassFloat::less_int);
	insertMethod("bool <(long)", &ClassFloat::less_long);
	insertMethod("bool <(real)", &ClassFloat::less_real);
	insertMethod("bool <(float)", &ClassFloat::less_float);
	insertMethod("bool <(double)", &ClassFloat::less_double);

	insertMethod("bool >=(char)", &ClassFloat::greater_equal_char);
	insertMethod("bool >=(short)", &ClassFloat::greater_equal_short);
	insertMethod("bool >=(int)", &ClassFloat::greater_equal_int);
	insertMethod("bool >=(long)", &ClassFloat::greater_equal_long);
	insertMethod("bool >=(real)", &ClassFloat::greater_equal_real);
	insertMethod("bool >=(float)", &ClassFloat::greater_equal_float);
	insertMethod("bool >=(double)", &ClassFloat::greater_equal_double);

	insertMethod("bool <=(char)", &ClassFloat::less_equal_char);
	insertMethod("bool <=(short)", &ClassFloat::less_equal_short);
	insertMethod("bool <=(int)", &ClassFloat::less_equal_int);
	insertMethod("bool <=(long)", &ClassFloat::less_equal_long);
	insertMethod("bool <=(real)", &ClassFloat::less_equal_real);
	insertMethod("bool <=(float)", &ClassFloat::less_equal_float);
	insertMethod("bool <=(double)", &ClassFloat::less_equal_double);

}

void ClassFloat::create(int argc, BValue* argv)
{
	argv[0].refer() = 0.0f;
}
void ClassFloat::create_bool(int argc, BValue* argv)
{
	bool b = argv[1];
	argv[0].refer() = b ? 1.0f : 0.0f;
}
void ClassFloat::create_char(int argc, BValue* argv)
{
	char c = argv[1];
	argv[0].refer() = (float)c;
}
void ClassFloat::create_short(int argc, BValue* argv)
{
	short s = argv[1];
	argv[0].refer() = (float)s;
}
void ClassFloat::create_int(int argc, BValue* argv)
{
	int i = argv[1];
	argv[0].refer() = (float)i;
}
void ClassFloat::create_long(int argc, BValue* argv)
{
	long long l = argv[1];
	argv[0].refer() = (float)l;
}
void ClassFloat::create_real(int argc, BValue* argv)
{
	BReal r = argv[1];
	argv[0].refer() = r;
}
void ClassFloat::create_float(int argc, BValue* argv)
{
	float f = argv[1];
	argv[0].refer() = f;
}
void ClassFloat::create_double(int argc, BValue* argv)
{
	double d = argv[1];
	argv[0].refer() = (float)d;
}
void ClassFloat::release(int argc, BValue* argv)
{
	argv[0].refer().clear();
}

void ClassFloat::assign_bool(int argc, BValue* argv)
{
	float& v = argv[0];
	bool b = argv[1];
	v = b ? 1.0f : 0.0f;
}
void ClassFloat::assign_char(int argc, BValue* argv)
{
	float& v = argv[0];
	char c = argv[1];
	v = (float)c;
}
void ClassFloat::assign_short(int argc, BValue* argv)
{
	float& v = argv[0];
	short s = argv[1];
	v = (float)s;
}
void ClassFloat::assign_int(int argc, BValue* argv)
{
	float& v = argv[0];
	int i = argv[1];
	v = (float)i;
}
void ClassFloat::assign_long(int argc, BValue* argv)
{
	float& v = argv[0];
	long long l = argv[1];
	v = (float)l;
}
void ClassFloat::assign_real(int argc, BValue* argv)
{
	float& v = argv[0];
	BReal r = argv[1];
	v = (float)r;
}
void ClassFloat::assign_float(int argc, BValue* argv)
{
	float& v = argv[0];
	float f = argv[1];
	v = (float)f;
}
void ClassFloat::assign_double(int argc, BValue* argv)
{
	float& v = argv[0];
	double d = argv[1];
	v = (float)d;
}

void ClassFloat::positive(int argc, BValue* argv)
{
	
}
void ClassFloat::negative(int argc, BValue* argv)
{
	float& v = argv[0];
	argv[0] = -v;
}
void ClassFloat::plus_plus(int argc, BValue* argv)
{
	float& v = argv[0];
	argv[0] = v++;
}
void ClassFloat::minus_minus(int argc, BValue* argv)
{
	float& v = argv[0];
	argv[0] = v--;
}

void ClassFloat::plus_char(int argc, BValue* argv)
{
	float v = argv[0];
	char c = argv[1];
	argv[0] = float(v + c);
}
void ClassFloat::plus_short(int argc, BValue* argv)
{
	float v = argv[0];
	short s = argv[1];
	argv[0] = float(v + s);
}
void ClassFloat::plus_int(int argc, BValue* argv)
{
	float v = argv[0];
	int i = argv[1];
	argv[0] = float(v + i);
}
void ClassFloat::plus_long(int argc, BValue* argv)
{
	float v = argv[0];
	long long l = argv[1];
	argv[0] = float(v + l);
}
void ClassFloat::plus_real(int argc, BValue* argv)
{
	float v = argv[0];
	BReal r = argv[1];
	argv[0] = float(v + r);
}
void ClassFloat::plus_float(int argc, BValue* argv)
{
	float v = argv[0];
	float f = argv[1];
	argv[0] = float(v + f);
}
void ClassFloat::plus_double(int argc, BValue* argv)
{
	float v = argv[0];
	double d = argv[1];
	argv[0] = float(v + d);
}

void ClassFloat::plus_assign_char(int argc, BValue* argv)
{
	float& v = argv[0];
	char c = argv[1];
	v += (float)c;
}
void ClassFloat::plus_assign_short(int argc, BValue* argv)
{
	float& v = argv[0];
	short s = argv[1];
	v += (float)s;
}
void ClassFloat::plus_assign_int(int argc, BValue* argv)
{
	float& v = argv[0];
	int i = argv[1];
	v += (float)i;
}
void ClassFloat::plus_assign_long(int argc, BValue* argv)
{
	float& v = argv[0];
	long long l = argv[1];
	v += (float)l;
}
void ClassFloat::plus_assign_real(int argc, BValue* argv)
{
	float& v = argv[0];
	BReal r = argv[1];
	v += (float)r;
}
void ClassFloat::plus_assign_float(int argc, BValue* argv)
{
	float& v = argv[0];
	float f = argv[1];
	v += f;
}
void ClassFloat::plus_assign_double(int argc, BValue* argv)
{
	float& v = argv[0];
	double d = argv[1];
	v = (float)(v + d);
}

void ClassFloat::minus_char(int argc, BValue* argv)
{
	float v = argv[0];
	char c = argv[1];
	argv[0] = float(v - c);
}
void ClassFloat::minus_short(int argc, BValue* argv)
{
	float v = argv[0];
	short s = argv[1];
	argv[0] = float(v - s);
}
void ClassFloat::minus_int(int argc, BValue* argv)
{
	float v = argv[0];
	int i = argv[1];
	argv[0] = float(v - i);
}
void ClassFloat::minus_long(int argc, BValue* argv)
{
	float v = argv[0];
	long long l = argv[1];
	argv[0] = float(v - l);
}
void ClassFloat::minus_real(int argc, BValue* argv)
{
	float v = argv[0];
	BReal r = argv[1];
	argv[0] = float(v - r);
}
void ClassFloat::minus_float(int argc, BValue* argv)
{
	float v = argv[0];
	float f = argv[1];
	argv[0] = float(v - f);
}
void ClassFloat::minus_double(int argc, BValue* argv)
{
	float v = argv[0];
	double d = argv[1];
	argv[0] = float(v - d);
}

void ClassFloat::minus_assign_char(int argc, BValue* argv)
{
	float& v = argv[0];
	char c = argv[1];
	v -= (float)c;
}
void ClassFloat::minus_assign_short(int argc, BValue* argv)
{
	float& v = argv[0];
	short s = argv[1];
	v -= (float)s;
}
void ClassFloat::minus_assign_int(int argc, BValue* argv)
{
	float& v = argv[0];
	int i = argv[1];
	v -= (float)i;
}
void ClassFloat::minus_assign_long(int argc, BValue* argv)
{
	float& v = argv[0];
	long long l = argv[1];
	v -= (float)l;
}
void ClassFloat::minus_assign_real(int argc, BValue* argv)
{
	float& v = argv[0];
	BReal r = argv[1];
	v -= (float)r;
}
void ClassFloat::minus_assign_float(int argc, BValue* argv)
{
	float& v = argv[0];
	float f = argv[1];
	v -= f;
}
void ClassFloat::minus_assign_double(int argc, BValue* argv)
{
	float& v = argv[0];
	double d = argv[1];
	v = (float)(v - d);
}

void ClassFloat::mult_char(int argc, BValue* argv)
{
	float v = argv[0];
	char c = argv[1];
	argv[0] = float(v * c);
}
void ClassFloat::mult_short(int argc, BValue* argv)
{
	float v = argv[0];
	short s = argv[1];
	argv[0] = float(v * s);
}
void ClassFloat::mult_int(int argc, BValue* argv)
{
	float v = argv[0];
	int i = argv[1];
	argv[0] = float(v * i);
}
void ClassFloat::mult_long(int argc, BValue* argv)
{
	float v = argv[0];
	long long l = argv[1];
	argv[0] = float(v * l);
}
void ClassFloat::mult_real(int argc, BValue* argv)
{
	float v = argv[0];
	BReal r = argv[1];
	argv[0] = float(v * r);
}
void ClassFloat::mult_float(int argc, BValue* argv)
{
	float v = argv[0];
	float f = argv[1];
	argv[0] = float(v * f);
}
void ClassFloat::mult_double(int argc, BValue* argv)
{
	float v = argv[0];
	double d = argv[1];
	argv[0] = float(v * d);
}

void ClassFloat::mult_assign_char(int argc, BValue* argv)
{
	float& v = argv[0];
	char c = argv[1];
	v *= (float)c;
}
void ClassFloat::mult_assign_short(int argc, BValue* argv)
{
	float& v = argv[0];
	short s = argv[1];
	v *= (float)s;
}
void ClassFloat::mult_assign_int(int argc, BValue* argv)
{
	float& v = argv[0];
	int i = argv[1];
	v *= (float)i;
}
void ClassFloat::mult_assign_long(int argc, BValue* argv)
{
	float& v = argv[0];
	long long l = argv[1];
	v *= (float)l;
}
void ClassFloat::mult_assign_real(int argc, BValue* argv)
{
	float& v = argv[0];
	BReal r = argv[1];
	v *= (float)r;
}
void ClassFloat::mult_assign_float(int argc, BValue* argv)
{
	float& v = argv[0];
	float f = argv[1];
	v *= f;
}
void ClassFloat::mult_assign_double(int argc, BValue* argv)
{
	float& v = argv[0];
	double d = argv[1];
	v = (float)(v * d);
}

void ClassFloat::div_char(int argc, BValue* argv)
{
	float v = argv[0];
	char c = argv[1];
	argv[0] = float(v / c);
}
void ClassFloat::div_short(int argc, BValue* argv)
{
	float v = argv[0];
	short s = argv[1];
	argv[0] = float(v / s);
}
void ClassFloat::div_int(int argc, BValue* argv)
{
	float v = argv[0];
	int i = argv[1];
	argv[0] = float(v / i);
}
void ClassFloat::div_long(int argc, BValue* argv)
{
	float v = argv[0];
	long long l = argv[1];
	argv[0] = float(v / l);
}
void ClassFloat::div_real(int argc, BValue* argv)
{
	float v = argv[0];
	BReal r = argv[1];
	argv[0] = float(v / r);
}
void ClassFloat::div_float(int argc, BValue* argv)
{
	float v = argv[0];
	float f = argv[1];
	argv[0] = float(v / f);
}
void ClassFloat::div_double(int argc, BValue* argv)
{
	float v = argv[0];
	double d = argv[1];
	argv[0] = float(v / d);
}

void ClassFloat::div_assign_char(int argc, BValue* argv)
{
	float& v = argv[0];
	char c = argv[1];
	v /= (float)c;
}
void ClassFloat::div_assign_short(int argc, BValue* argv)
{
	float& v = argv[0];
	short s = argv[1];
	v /= (float)s;
}
void ClassFloat::div_assign_int(int argc, BValue* argv)
{
	float& v = argv[0];
	int i = argv[1];
	v /= (float)i;
}
void ClassFloat::div_assign_long(int argc, BValue* argv)
{
	float& v = argv[0];
	long long l = argv[1];
	v /= (float)l;
}
void ClassFloat::div_assign_real(int argc, BValue* argv)
{
	float& v = argv[0];
	BReal r = argv[1];
	v /= (float)r;
}
void ClassFloat::div_assign_float(int argc, BValue* argv)
{
	float& v = argv[0];
	float f = argv[1];
	v /= f;
}
void ClassFloat::div_assign_double(int argc, BValue* argv)
{
	float& v = argv[0];
	double d = argv[1];
	v = (float)(v / d);
}

void ClassFloat::mod_char(int argc, BValue* argv)
{
	float v = argv[0];
	char c = argv[1];
	argv[0] = fmodf(v, c);
}
void ClassFloat::mod_short(int argc, BValue* argv)
{
	float v = argv[0];
	short s = argv[1];
	argv[0] = fmodf(v, s);
}
void ClassFloat::mod_int(int argc, BValue* argv)
{
	float v = argv[0];
	int i = argv[1];
	argv[0] = fmodf(v, (float)i);
}
void ClassFloat::mod_long(int argc, BValue* argv)
{
	float v = argv[0];
	long long l = argv[1];
	argv[0] = fmodf(v, (float)l);
}
void ClassFloat::mod_real(int argc, BValue* argv)
{
	float v = argv[0];
	BReal r = argv[1];
	argv[0] = fmodf(v, (float)r);
}
void ClassFloat::mod_float(int argc, BValue* argv)
{
	float v = argv[0];
	float f = argv[1];
	argv[0] = fmodf(v, f);
}
void ClassFloat::mod_double(int argc, BValue* argv)
{
	float v = argv[0];
	double d = argv[1];
	argv[0] = fmodf(v, (float)d);
}

void ClassFloat::mod_assign_char(int argc, BValue* argv)
{
	float& v = argv[0];
	char c = argv[1];
	argv[0] = v = fmodf(v, (float)c);
}
void ClassFloat::mod_assign_short(int argc, BValue* argv)
{
	float& v = argv[0];
	short s = argv[1];
	argv[0] = v = fmodf(v, (float)s);
}
void ClassFloat::mod_assign_int(int argc, BValue* argv)
{
	float& v = argv[0];
	int i = argv[1];
	argv[0] = v = fmodf(v, (float)i);
}
void ClassFloat::mod_assign_long(int argc, BValue* argv)
{
	float& v = argv[0];
	long long l = argv[1];
	argv[0] = v = fmodf(v, (float)l);
}
void ClassFloat::mod_assign_real(int argc, BValue* argv)
{
	float& v = argv[0];
	BReal r = argv[1];
	argv[0] = v = fmodf(v, (float)r);
}
void ClassFloat::mod_assign_float(int argc, BValue* argv)
{
	float& v = argv[0];
	float f = argv[1];
	argv[0] = v = fmodf(v, f);
}
void ClassFloat::mod_assign_double(int argc, BValue* argv)
{
	float& v = argv[0];
	double d = argv[1];
	argv[0] = v = fmodf(v, (float)d);
}

void ClassFloat::equal_char(int argc, BValue* argv)
{
	float v = argv[0];
	char c = argv[1];
	argv[0] = (v == c);
}
void ClassFloat::equal_short(int argc, BValue* argv)
{
	float v = argv[0];
	short s = argv[1];
	argv[0] = (v == s);
}
void ClassFloat::equal_int(int argc, BValue* argv)
{
	float v = argv[0];
	int i = argv[1];
	argv[0] = (v == i);
}
void ClassFloat::equal_long(int argc, BValue* argv)
{
	float v = argv[0];
	long l = argv[1];
	argv[0] = (v == l);
}
void ClassFloat::equal_real(int argc, BValue* argv)
{
	float v = argv[0];
	BReal r = argv[1];
	argv[0] = (v == r);
}
void ClassFloat::equal_float(int argc, BValue* argv)
{
	float v = argv[0];
	float f = argv[1];
	argv[0] = (v == f);
}
void ClassFloat::equal_double(int argc, BValue* argv)
{
	float v = argv[0];
	double d = argv[1];
	argv[0] = (v == d);
}

void ClassFloat::unequal_char(int argc, BValue* argv)
{
	float v = argv[0];
	char c = argv[1];
	argv[0] = (v != c);
}
void ClassFloat::unequal_short(int argc, BValue* argv)
{
	float v = argv[0];
	short s = argv[1];
	argv[0] = (v != s);
}
void ClassFloat::unequal_int(int argc, BValue* argv)
{
	float v = argv[0];
	int i = argv[1];
	argv[0] = (v != i);
}
void ClassFloat::unequal_long(int argc, BValue* argv)
{
	float v = argv[0];
	long l = argv[1];
	argv[0] = (v != l);
}
void ClassFloat::unequal_real(int argc, BValue* argv)
{
	float v = argv[0];
	BReal r = argv[1];
	argv[0] = (v != r);
}
void ClassFloat::unequal_float(int argc, BValue* argv)
{
	float v = argv[0];
	float f = argv[1];
	argv[0] = (v != f);
}
void ClassFloat::unequal_double(int argc, BValue* argv)
{
	float v = argv[0];
	double d = argv[1];
	argv[0] = (v != d);
}

void ClassFloat::greater_char(int argc, BValue* argv)
{
	float v = argv[0];
	char c = argv[1];
	argv[0] = (v > c);
}
void ClassFloat::greater_short(int argc, BValue* argv)
{
	float v = argv[0];
	short s = argv[1];
	argv[0] = (v > s);
}
void ClassFloat::greater_int(int argc, BValue* argv)
{
	float v = argv[0];
	int i = argv[1];
	argv[0] = (v > i);
}
void ClassFloat::greater_long(int argc, BValue* argv)
{
	float v = argv[0];
	long long l = argv[1];
	argv[0] = (v > l);
}
void ClassFloat::greater_real(int argc, BValue* argv)
{
	float v = argv[0];
	BReal r = argv[1];
	argv[0] = (v > r);
}
void ClassFloat::greater_float(int argc, BValue* argv)
{
	float v = argv[0];
	float f = argv[1];
	argv[0] = (v > f);
}
void ClassFloat::greater_double(int argc, BValue* argv)
{
	float v = argv[0];
	double d = argv[1];
	argv[0] = (v > d);
}

void ClassFloat::greater_equal_char(int argc, BValue* argv)
{
	float v = argv[0];
	char c = argv[1];
	argv[0] = (v >= c);
}
void ClassFloat::greater_equal_short(int argc, BValue* argv)
{
	float v = argv[0];
	short s = argv[1];
	argv[0] = (v >= s);
}
void ClassFloat::greater_equal_int(int argc, BValue* argv)
{
	float v = argv[0];
	int i = argv[1];
	argv[0] = (v >= i);
}
void ClassFloat::greater_equal_long(int argc, BValue* argv)
{
	float v = argv[0];
	long long l = argv[1];
	argv[0] = (v >= l);
}
void ClassFloat::greater_equal_real(int argc, BValue* argv)
{
	float v = argv[0];
	BReal r = argv[1];
	argv[0] = (v >= r);
}
void ClassFloat::greater_equal_float(int argc, BValue* argv)
{
	float v = argv[0];
	float f = argv[1];
	argv[0] = (v >= f);
}
void ClassFloat::greater_equal_double(int argc, BValue* argv)
{
	float v = argv[0];
	double d = argv[1];
	argv[0] = (v >= d);
}

void ClassFloat::less_char(int argc, BValue* argv)
{
	float v = argv[0];
	char c = argv[1];
	argv[0] = (v < c);
}
void ClassFloat::less_short(int argc, BValue* argv)
{
	float v = argv[0];
	short s = argv[1];
	argv[0] = (v < s);
}
void ClassFloat::less_int(int argc, BValue* argv)
{
	float v = argv[0];
	int i = argv[1];
	argv[0] = (v < i);
}
void ClassFloat::less_long(int argc, BValue* argv)
{
	float v = argv[0];
	long long l = argv[1];
	argv[0] = (v < l);
}
void ClassFloat::less_real(int argc, BValue* argv)
{
	float v = argv[0];
	BReal r = argv[1];
	argv[0] = (v < r);
}
void ClassFloat::less_float(int argc, BValue* argv)
{
	float v = argv[0];
	float f = argv[1];
	argv[0] = (v < f);
}
void ClassFloat::less_double(int argc, BValue* argv)
{
	float v = argv[0];
	double d = argv[1];
	argv[0] = (v < d);
}

void ClassFloat::less_equal_char(int argc, BValue* argv)
{
	float v = argv[0];
	char c = argv[1];
	argv[0] = (v <= c);
}
void ClassFloat::less_equal_short(int argc, BValue* argv)
{
	float v = argv[0];
	short s = argv[1];
	argv[0] = (v <= s);
}
void ClassFloat::less_equal_int(int argc, BValue* argv)
{
	float v = argv[0];
	int i = argv[1];
	argv[0] = (v <= i);
}
void ClassFloat::less_equal_long(int argc, BValue* argv)
{
	float v = argv[0];
	long long l = argv[1];
	argv[0] = (v <= l);
}
void ClassFloat::less_equal_real(int argc, BValue* argv)
{
	float v = argv[0];
	BReal r = argv[1];
	argv[0] = (v <= r);
}
void ClassFloat::less_equal_float(int argc, BValue* argv)
{
	float v = argv[0];
	float f = argv[1];
	argv[0] = (v <= f);
}
void ClassFloat::less_equal_double(int argc, BValue* argv)
{
	float v = argv[0];
	double d = argv[1];
	argv[0] = (v <= d);
}
